package org.jeecg.modules.simulator.util;

import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @program: gp
 * @description:
 * @author: lydms
 * @create: 2024-08-07 14:58
 **/
@Slf4j
public class TimeUtil {
    private static final Logger logger = LoggerFactory.getLogger(TimeUtil.class);

    public static int calculateSecondsDifference2(String time1, String time2) {
        // 定义日期格式
        SimpleDateFormat format = new SimpleDateFormat("HH:mm:ss");

        try {
            // 解析字符串为 Date 对象
            Date date1 = format.parse(time1);
            Date date2 = format.parse(time2);

            // 计算时间差（以毫秒为单位）
            long differenceInMillis = date2.getTime() - date1.getTime();

            // 转换为秒
            return (int) (differenceInMillis / 1000);
        } catch (ParseException e) {
            e.printStackTrace();
            return 0; // 在解析异常的情况下返回 0 或者可以选择抛出异常
        }
    }


    public static int calculateSecondsDifference(String time1, String time2) {
        // 定义日期格式
        SimpleDateFormat format = new SimpleDateFormat("HH:mm:ss");

        try {
            // 解析字符串为 Date 对象
            Date date1 = format.parse(time1);
            Date date2 = format.parse(time2);

            // 计算时间差（以毫秒为单位）
            long differenceInMillis = date2.getTime() - date1.getTime();

            // 转换为秒
            return (int) (differenceInMillis / 1000);
        } catch (ParseException e) {
            e.printStackTrace();
            return 0; // 在解析异常的情况下返回 0 或者可以选择抛出异常
        }
    }

    public static String convertToHHmmss(String dateString) {
        // 定义输入日期格式
        SimpleDateFormat dateFormat = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy", Locale.ENGLISH);
        // 设置输入格式的时区
        dateFormat.setTimeZone(TimeZone.getTimeZone("CST"));

        // 定义输出时间格式
        SimpleDateFormat outputFormat = new SimpleDateFormat("HH:mm:ss");
        outputFormat.setTimeZone(TimeZone.getTimeZone("CST")); // 设置输出格式的时区

        try {
            // 解析输入日期字符串
            Date date = dateFormat.parse(dateString);
            // 格式化为目标格式
            return outputFormat.format(date);
        } catch (ParseException e) {
            e.printStackTrace();
            return null;
        }
    }
    public static String convertDateTimeFormat(String dateTimeString) {
        // 定义输入格式
        DateTimeFormatter inputFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");
        // 解析字符串为 LocalDateTime
        LocalDateTime dateTime = LocalDateTime.parse(dateTimeString, inputFormatter);
        // 定义输出格式
        DateTimeFormatter outputFormatter = DateTimeFormatter.ofPattern("HH:mm:ss");
        // 格式化为所需的时间字符串
        return dateTime.format(outputFormatter);
    }

        public static LocalTime convertStringToLocalTime(String timeString) {
            // 定义时间格式
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss");

            try {
                // 解析字符串为 LocalTime
                return LocalTime.parse(timeString, formatter);
            } catch (DateTimeParseException e) {
                logger.debug("时间格式错误: " + e.getMessage());
                return null; // 或者抛出异常
            }
        }
    public static boolean containsSeconds(String timeString) {
        // 正则表达式检查时间格式是否包含秒
        return timeString.matches("\\d{2}:\\d{2}:\\d{2}");
    }
        /**
         * @description: 1、time1 在 time2  之前，返回 1
         * 2、time1 在 time2  之后，返回 2
         * 3、time1 和 time2 是相等的
         * @author: renzhg
         * @date: 2024/8/6 15:01
         * @param:
         * @param: null
         * @return:
         * @return: null
         **/
        public static int compareLocalTimes(LocalTime time1, LocalTime time2) {

            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("hh:mm:ss");

            // 将 LocalTime 格式化为字符串


            if (time1.isBefore(time2)) {
                return 1;
            } else if (time1.isAfter(time2)) {
                return 2;
            } else {
                return 0;
            }
        }


        /**
         * 比较时间是否相等
         */
        public static boolean compareTimeIsEq(LocalTime time, String trimestr) {
            try {
                // 假设字符串格式为 "HH:mm:ss"，可以根据需要调整
                DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss");
                LocalTime parsedTime = LocalTime.parse(trimestr, formatter);
                return time.equals(parsedTime);
            } catch (DateTimeParseException e) {
                // 处理解析异常，例如格式不正确
                System.out.println("时间格式不正确: " + e.getMessage());
                return false;
            }
        }


        public static void printLcaltime(LocalTime localTime) {
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss");
            String formattedTime = localTime.format(formatter);
//        System.out.println("格式化后的时间: " + formattedTime);
        }


    public static String checkDateTime(String input) {
        // 日期正则表达式 (yyyy-MM-dd 或 MM/dd/yyyy)
        String datePattern = "\\d{4}-\\d{2}-\\d{2}|\\d{2}/\\d{2}/\\d{4}";
        // 时间正则表达式 (HH:mm:ss 或 hh:mm a)
        String timePattern = "(\\d{2}:\\d{2}:\\d{2})|(\\d{1,2}:\\d{2}(?:\\s?[AP]M)?)";

        String hhmmPattern = "^([01]?\\d|2[0-3]):([0-5]\\d)$";
        Pattern dateRegex = Pattern.compile(datePattern);
        Pattern timeRegex = Pattern.compile(timePattern);
        boolean matchesHHmm = Pattern.matches(hhmmPattern, input);
        Matcher dateMatcher = dateRegex.matcher(input);
        Matcher timeMatcher = timeRegex.matcher(input);

        boolean hasDate = dateMatcher.find();
        boolean hasTime = timeMatcher.find();

        if (hasDate && hasTime) {
            return "DATE_AND_TIME"; // 同时包含日期和时间
        } else if (hasTime) {
            if(matchesHHmm){
                return "ONLY_HOUR";
            }
            return "ONLY_TIME"; // 仅包含时间
        }  else if (hasDate) {
            return "ONLY_DATE"; // 仅包含日期
        } else {
            return "INVALID"; // 无效字符串
        }
    }

    public static String compareStrTimes(String time1, String time2) {
        DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("HH:mm:ss");

        LocalTime t1 = LocalTime.parse(time1, timeFormatter);
        LocalTime t2 = LocalTime.parse(time2, timeFormatter);

        // 比较时间
        if (t1.isBefore(t2)) {
            //time1 + " is earlier than " + time2;
            return "1";
        } else if (t1.isAfter(t2)) {
            // time1 + " is later than " + time2;
            return "2";
        } else {
            //time1 + " is the same as " + time2;
            return "0";
        }
    }

    public static List<String> generateTimeSlots(LocalTime startTime, LocalTime endTime) {
        // 时间格式化
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss");
        List<String> timeSlots = new ArrayList<>();

        // 当前时间初始化为开始时间减去5分钟
        LocalTime currentTime = startTime.minusMinutes(5);

        // 遍历时间片直到结束时间
        while (currentTime.isBefore(endTime) || currentTime.equals(endTime)) {
            // 添加当前时间到列表
            timeSlots.add(currentTime.format(formatter));
            // 增加5分钟
            currentTime = currentTime.plusMinutes(5);
        }

        return timeSlots;
    }



    public static LocalTime transTimeString2LocalTime(String timeString) {
        return LocalTime.parse(timeString, DateTimeFormatter.ofPattern("HH:mm:ss"));
    }



    public static String Lcaltime2String(LocalTime localTime) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss");
        return localTime.format(formatter);

    }




    public static int findTimeSlotIndex(List<String> timeSlots, String timePoint) {
        LocalTime pointTime = LocalTime.parse(timePoint, DateTimeFormatter.ofPattern("HH:mm:ss"));
        for (int i = 0; i < timeSlots.size(); i++) {
            LocalTime slotTime = LocalTime.parse(timeSlots.get(i), DateTimeFormatter.ofPattern("HH:mm:ss"));
            if (slotTime.equals(pointTime)) {
                return i; // 返回索引
            }
        }
        return -1; // 如果没有找到，返回-1
    }
}

